home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Cream of the Crop 3
/
Cream of the Crop 3.iso
/
comm
/
wnos5src.zip
/
IP.C
< prev
next >
Wrap
Text File
|
1993-08-09
|
13KB
|
492 lines
/* Upper half of IP, consisting of send/receive primitives, including
* fragment reassembly, for higher level protocols.
* Not needed when running as a standalone gateway.
*/
#include "global.h"
#include "mbuf.h"
#include "timer.h"
#include "internet.h"
#include "netuser.h"
#include "iface.h"
#include "pktdrvr.h"
#include "ip.h"
#include "icmp.h"
static struct mbuf * near fraghandle __ARGS((struct ip *ip,struct mbuf *bp));
static void ip_timeout __ARGS((void *arg));
static void near free_reasm __ARGS((struct reasm *rp));
static void near freefrag __ARGS((struct frag *fp));
static struct reasm * near lookup_reasm __ARGS((struct ip *ip));
static struct reasm * near creat_reasm __ARGS((struct ip *ip));
static struct frag * near newfrag __ARGS((int16 offset,int16 last,struct mbuf *bp));
struct mib_entry Ip_mib[20] = {
"", 0,
"Forwarding", 1,
"DefaultTTL", MAXTTL,
"InReceives", 0,
"InHdrErrors", 0,
"InAddrErrors", 0,
"ForwDatagrams", 0,
"InUnknownProtos", 0,
"InDiscards", 0,
"InDelivers", 0,
"OutRequests", 0,
"OutDiscards", 0,
"OutNoRoutes", 0,
"ReasmTimeout", TLB,
"ReasmReqds", 0,
"ReasmOKs", 0,
"ReasmFails", 0,
"FragOKs", 0,
"FragFails", 0,
"FragCreates", 0,
};
struct reasm *Reasmq = NULLREASM;
static struct raw_ip *Raw_ip = NULLRIP;
#define INSERT 0
#define APPEND 1
#define PREPEND 2
/* Send an IP datagram. Modeled after the example interface on p 32 of
* RFC 791
*/
int
ip_send(
int32 source, /* source address */
int32 dest, /* Destination address */
char protocol, /* Protocol */
char tos, /* Type of service */
char ttl, /* Time-to-live */
struct mbuf *bp, /* Data portion of datagram */
int16 length, /* Optional length of data portion */
int16 id, /* Optional identification */
char df) /* Don't-fragment flag */
{
struct mbuf *tbp;
struct ip ip; /* Pointer to IP header */
static int16 id_cntr; /* Datagram serial number */
struct phdr phdr;
ipOutRequests++;
if(source == INADDR_ANY)
source = locaddr(dest);
if(length == 0 && bp != NULLBUF)
length = len_p(bp);
if(id == 0)
id = id_cntr++;
if(ttl == 0)
ttl = ipDefaultTTL;
/* Fill in IP header */
ip.version = IPVERSION;
ip.tos = tos;
ip.length = IPLEN + length;
ip.id = id;
ip.flags.mf = ip.flags.congest = ip.optlen = ip.offset = 0;
ip.flags.df = df;
ip.ttl = ttl;
ip.protocol = protocol;
ip.source = source;
ip.dest = dest;
tbp = htonip(&ip,bp,0);
bp = pushdown(tbp,sizeof(struct phdr));
if(ismyaddr(ip.dest)) {
/* Pretend it has been sent by the loopback interface before
* it appears in the receive queue
*/
phdr.iface = &Loopback;
Loopback.ipsndcnt++;
Loopback.rawsndcnt++;
Loopback.lastsent = secclock();
} else {
phdr.iface = NULLIF;
}
phdr.type = CL_NONE;
memcpy(bp->data,(char *)&phdr,sizeof(struct phdr));
enqueue(&Hopper,bp);
return 0;
}
/* Reassemble incoming IP fragments and dispatch completed datagrams
* to the proper transport module
*/
void
ip_recv(
struct iface *iface, /* Incoming interface */
struct ip *ip, /* Extracted IP header */
struct mbuf *bp, /* Data portion */
int rxbroadcast) /* True if received on subnet broadcast address */
{
/* Function to call with completed datagram */
struct raw_ip *rp;
struct mbuf *bp1, *tbp;
int rxcnt = 0;
struct iplink *ipp;
/* If we have a complete packet, call the next layer
* to handle the result. Note that fraghandle passes back
* a length field that does NOT include the IP header
*/
if((bp = fraghandle(ip,bp)) == NULLBUF)
/* Not done yet */
return;
ipInDelivers++;
for(rp = Raw_ip; rp != NULLRIP; rp = rp->next) {
if(rp->protocol != ip->protocol)
continue;
rxcnt++;
/* Duplicate the data portion, and put the header back on */
dup_p(&bp1,bp,0,len_p(bp));
if(bp1 != NULLBUF) {
tbp = htonip(ip,bp1,1);
enqueue(&rp->rcvq,tbp);
if(rp->r_upcall != NULLVFP)
(*rp->r_upcall)(rp);
} else {
free_p(bp1);
}
}
/* Look it up in the transport protocol table */
for(ipp = Iplink;ipp->funct != NULL;ipp++){
if(ipp->proto == ip->protocol)
break;
}
if(ipp->funct != NULL){
/* Found, call transport protocol */
(*ipp->funct)(iface,ip,bp,rxbroadcast);
} else {
/* Not found */
if(rxcnt == 0) {
/* Send an ICMP Protocol Unknown response... */
ipInUnknownProtos++;
/* ...unless it's a broadcast */
if(!rxbroadcast) {
icmp_output(ip,bp,ICMP_DEST_UNREACH,ICMP_PROT_UNREACH,NULLICMP);
}
}
free_p(bp);
}
}
/* Handle IP packets encapsulated inside IP */
void
ipip_recv(
struct iface *iface, /* Incoming interface */
struct ip *ip, /* Extracted IP header */
struct mbuf *bp, /* Data portion */
int rxbroadcast) /* True if received on subnet broadcast address */
{
struct phdr phdr;
struct mbuf *tbp = pushdown(bp,sizeof(struct phdr));
bp = tbp;
phdr.iface = &Encap;
phdr.type = CL_NONE;
memcpy(bp->data,(char *)&phdr,sizeof(struct phdr));
enqueue(&Hopper,bp);
}
/* Process IP datagram fragments
* If datagram is complete, return it with ip->length containing the data
* length (MINUS header); otherwise return NULLBUF
*/
static struct mbuf * near
fraghandle(
struct ip *ip, /* IP header, host byte order */
struct mbuf *bp) /* The fragment itself */
{
struct frag *lastfrag = NULLFRAG, *nextfrag, *tfp;
struct mbuf *tbp;
int16 i;
/* Index of first byte beyond fragment */
int16 last = ip->offset + ip->length - (IPLEN + ip->optlen);
/* Pointer to reassembly descriptor */
struct reasm *rp = lookup_reasm(ip);
if(ip->offset == 0 && !ip->flags.mf) {
/* Complete datagram received. Discard any earlier fragments */
if(rp != NULLREASM) {
free_reasm(rp);
ipReasmOKs++;
}
return bp;
}
ipReasmReqds++;
/* First fragment; create new reassembly descriptor */
if(rp == NULLREASM && (rp = creat_reasm(ip)) == NULLREASM) {
/* No space for descriptor, drop fragment */
ipReasmFails++;
free_p(bp);
return NULLBUF;
}
/* Keep restarting timer as long as we keep getting fragments */
stop_timer(&rp->timer);
start_timer(&rp->timer);
/* If this is the last fragment, we now know how long the
* entire datagram is; record it
*/
if(!ip->flags.mf)
rp->length = last;
/* Set nextfrag to the first fragment which begins after us,
* and lastfrag to the last fragment which begins before us
*/
for(nextfrag = rp->fraglist; nextfrag != NULLFRAG; nextfrag = nextfrag->next) {
if(nextfrag->offset > ip->offset)
break;
lastfrag = nextfrag;
}
/* Check for overlap with preceeding fragment */
if(lastfrag != NULLFRAG && ip->offset < lastfrag->last) {
/* Strip overlap from new fragment */
i = lastfrag->last - ip->offset;
pullup(&bp,NULLCHAR,i);
if(bp == NULLBUF)
return NULLBUF; /* Nothing left */
ip->offset += i;
}
/* Look for overlap with succeeding segments */
for(; nextfrag != NULLFRAG; nextfrag = tfp) {
tfp = nextfrag->next; /* save in case we delete fp */
if(nextfrag->offset >= last)
break; /* Past our end */
/* Trim the front of this entry; if nothing is
* left, remove it.
*/
i = last - nextfrag->offset;
pullup(&nextfrag->buf,NULLCHAR,i);
if(nextfrag->buf == NULLBUF){
/* superseded; delete from list */
if(nextfrag->prev != NULLFRAG)
nextfrag->prev->next = nextfrag->next;
else
rp->fraglist = nextfrag->next;
if(tfp->next != NULLFRAG)
nextfrag->next->prev = nextfrag->prev;
freefrag(nextfrag);
} else {
nextfrag->offset = last;
}
}
/* Lastfrag now points, as before, to the fragment before us;
* nextfrag points at the next fragment. Check to see if we can
* join to either or both fragments.
*/
i = INSERT;
if(lastfrag != NULLFRAG && lastfrag->last == ip->offset)
i |= APPEND;
if(nextfrag != NULLFRAG && nextfrag->offset == last)
i |= PREPEND;
switch(i){
case INSERT: /* Insert new desc between lastfrag and nextfrag */
tfp = newfrag(ip->offset,last,bp);
tfp->prev = lastfrag;
tfp->next = nextfrag;
if(lastfrag != NULLFRAG)
lastfrag->next = tfp; /* Middle of list */
else
rp->fraglist = tfp; /* First on list */
if(nextfrag != NULLFRAG)
nextfrag->prev = tfp;
break;
case APPEND: /* Append to lastfrag */
append(&lastfrag->buf,bp);
lastfrag->last = last; /* Extend forward */
break;
case PREPEND: /* Prepend to nextfrag */
tbp = nextfrag->buf;
nextfrag->buf = bp;
append(&nextfrag->buf,tbp);
nextfrag->offset = ip->offset; /* Extend backward */
break;
case (APPEND|PREPEND):
/* Consolidate by appending this fragment and nextfrag
* to lastfrag and removing the nextfrag descriptor */
append(&lastfrag->buf,bp);
append(&lastfrag->buf,nextfrag->buf);
nextfrag->buf = NULLBUF;
lastfrag->last = nextfrag->last;
/* Finally unlink and delete the now unneeded nextfrag */
lastfrag->next = nextfrag->next;
if(nextfrag->next != NULLFRAG)
nextfrag->next->prev = lastfrag;
freefrag(nextfrag);
break;
}
if(rp->fraglist->offset == 0 && rp->fraglist->next == NULLFRAG
&& rp->length != 0){
/* We've gotten a complete datagram, so extract it from the
* reassembly buffer and pass it on.
*/
bp = rp->fraglist->buf;
rp->fraglist->buf = NULLBUF;
/* Tell IP the entire length */
ip->length = rp->length + (IPLEN + ip->optlen);
free_reasm(rp);
ipReasmOKs++;
return bp;
} else {
return NULLBUF;
}
}
/* Arrange for receipt of raw IP datagrams */
struct raw_ip *
raw_ip(int protocol,void (*r_upcall)())
{
struct raw_ip *rp = mxallocw(sizeof(struct raw_ip));
rp->protocol = protocol;
rp->r_upcall = r_upcall;
rp->next = Raw_ip;
Raw_ip = rp;
return rp;
}
/* Free a raw IP descriptor */
void
del_ip(struct raw_ip *rpp)
{
struct raw_ip *rp, *rplast = NULLRIP;
/* Do sanity check on arg */
for(rp = Raw_ip; rp != NULLRIP; rplast = rp, rp = rp->next)
if(rp == rpp)
break;
if(rp == NULLRIP)
return; /* Doesn't exist */
/* Unlink */
if(rplast != NULLRIP)
rplast->next = rp->next;
else
Raw_ip = rp->next;
/* Free resources */
free_q(&rp->rcvq);
xfree(rp);
}
static struct reasm * near
lookup_reasm(struct ip *ip)
{
struct reasm *rp, *rplast = NULLREASM;
for(rp = Reasmq; rp != NULLREASM; rplast = rp, rp = rp->next){
if(ip->id == rp->id
&& ip->source == rp->source
&& ip->dest == rp->dest
&& ip->protocol == rp->protocol) {
if(rplast != NULLREASM) {
/* Move to top of list for speed */
rplast->next = rp->next;
rp->next = Reasmq;
Reasmq = rp;
}
return rp;
}
}
return NULLREASM;
}
/* Create a reassembly descriptor,
* put at head of reassembly list
*/
static struct reasm * near
creat_reasm(struct ip *ip)
{
struct reasm *rp = mxallocw(sizeof(struct reasm));
rp->source = ip->source;
rp->dest = ip->dest;
rp->id = ip->id;
rp->protocol = ip->protocol;
rp->timer.func = ip_timeout;
rp->timer.arg = rp;
set_timer(&rp->timer,ipReasmTimeout * 1000L);
rp->next = Reasmq;
Reasmq = rp;
return rp;
}
/* Free all resources associated with a reassembly descriptor */
static void near
free_reasm(struct reasm *r)
{
struct reasm *rp, *rplast = NULLREASM;
struct frag *fp;
for(rp = Reasmq; rp != NULLREASM; rplast = rp, rp = rp->next)
if(r == rp)
break;
if(rp == NULLREASM)
return; /* Not on list */
/* Remove from list of reassembly descriptors */
if(rplast != NULLREASM)
rplast->next = rp->next;
else
Reasmq = rp->next;
stop_timer(&rp->timer);
/* Free any fragments on list, starting at beginning */
while((fp = rp->fraglist) != NULLFRAG){
rp->fraglist = fp->next;
free_p(fp->buf);
xfree(fp);
}
xfree(rp);
}
/* Handle reassembly timeouts by deleting all reassembly resources */
static void
ip_timeout(void *arg)
{
free_reasm((struct reasm *)arg);
ipReasmFails++;
}
/* Create a fragment */
static struct frag * near
newfrag(int16 offset,int16 last,struct mbuf *bp)
{
struct frag *fp = mxallocw(sizeof(struct frag));
fp->buf = bp;
fp->offset = offset;
fp->last = last;
return fp;
}
/* Delete a fragment, return next one on queue */
static void near
freefrag(struct frag *fp)
{
free_p(fp->buf);
xfree(fp);
}